Conventional software products and services often include a hard coded software program with inter-dependencies among various blocks of code in the hard coded software program flow. Such a hard coded software program is difficult to code with complex relations and/or dependencies and is not amenable to modifications, especially in software products and services providing customized user experiences in response to user inputs. Conventionally, the flow sequence is hard coded in the software program, and thus any modifications disturbing the flow sequence necessarily involves breaking up one or more edges (when the software program is viewed as a directed graph), modifying one or more nodes (e.g., adding or removing one or more nodes or changing the locations of two or more nodes) in the flow, and re-establishing one or more new edges to accommodate the modified one or more nodes.
Software programs with a flow sequence or navigation algorithm that is hard-coded in the software programs also cause inefficiencies during execution. Such hard-coded flow sequences, navigation algorithms, or their corresponding graphs or data structures often need to be traversed hierarchically or a large number of configurable objects and sometimes even through nodes or objects that may be irrelevant to a specific user and thus consume unnecessary computational resources. These conventional software programs with hard-coded flow sequences or navigation algorithms are also more difficult to present customizable or personal experiences for different users. For example, in an electronic tax return preparation and filing software application (both the hosted and the stand-alone versions), a user is often presented with a series of interview screens to collect sufficient information about the user and to determine which sections of a tax form may be pertinent to the user's tax filing. Modern electronic tax return preparation and filing software applications attempt to streamline the interview by selecting relevant interview screens from a large number of interview screens stored in a repository and presenting only the selected interview screens to a specific user.
Although some logic or even intelligence may be built into such conventional software programs, these modern software applications still suffer from the same problems with having to traverse a tree- or table-like structure (e.g., a directed graph, a tabular structure, a navigation algorithm, etc.) to identify the relevant object models (e.g., interview screens for an electronic tax preparation and filing software product or service delivery model). Also, such a tree- or table-like structure, once hard coded, is not amenable to modifications that alter the logic flow therein. These problems are further exacerbated by the sheer amount of interview screens often exceeding 50,000 interview screens and/or interview questions in modern electronic tax return preparation and filing software application.
The inter-dependencies or inter-relations among at least some of these interview screens further hinder the development of such software applications. For example, more computational resources will be expended during the prototyping, designing, implementation, testing, verification, integration, etc. of software products or services simply because of the complexities and hence modifications (e.g., by removing a part of the original logic flow, introducing changes to one or more blocks or sections of the underlying code, and re-establishing a new logic and connections involving the one or more blocks or sections of code) of the underlying logic of a modern software application and further because of the sheer number of various object models and/or code modules that have to be parsed through and thus accommodated in the memory of a computing system and processed with processor cycles.
To address at least these technological challenges and difficulties, there is therefore a need for methods, systems, and computer program products for implementing software products or services with dynamic conditions and dynamic actions as well as a need for methods, systems, and computer program products for implementing intelligent systems with dynamic configurability.